home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / rpc / rpcStubs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-12-19  |  8.9 KB  |  265 lines
  1. /*
  2.  * rpcStubs.c --
  3.  *
  4.  *    The stub procedures for the Rpc service procedures.
  5.  *
  6.  * Copyright 1990 Regents of the University of California
  7.  * Permission to use, copy, modify, and distribute this
  8.  * software and its documentation for any purpose and without
  9.  * fee is hereby granted, provided that the above copyright
  10.  * notice appear in all copies.  The University of California
  11.  * makes no representations about the suitability of this
  12.  * software for any purpose.  It is provided "as is" without
  13.  * express or implied warranty.
  14.  */
  15.  
  16. #ifndef lint
  17. static char rcsid[] = "$Header: /cdrom/src/kernel/Cvsroot/kernel/rpc/rpcStubs.c,v 9.9 92/12/13 18:21:39 mgbaker Exp $ SPRITE (Berkeley)";
  18. #endif /* not lint */
  19.  
  20. #include <sprite.h>
  21.  
  22. #include <stdlib.h>
  23. #include <rpc.h>
  24. #include <rpcInt.h>
  25. #include <rpcServer.h>
  26. #include <fsrmtRpcStubs.h>
  27. #include <fsconsist.h>
  28. #include <fsutil.h>
  29. #include <procMigrate.h>
  30. #include <timer.h>
  31. #include <sync.h>
  32. #include <sig.h>
  33. #include <fsio.h>
  34. #include <fsioRpc.h>
  35.  
  36. /*
  37.  * The RPC service procedure switch.  This table and the arguments
  38.  * to the RPC's themselves define the network interface to Sprite.
  39.  * Change things carefully!  You can either add new RPCs to the end,
  40.  * or you can change the RPC_VERSION number defined in rpcPacket.h
  41.  * and create a new in-compatible network interface.
  42.  */
  43.  
  44. RpcService rpcService[RPC_LAST_COMMAND+1] = {
  45.         RpcNull, "0",                          /* 0 - nothing */
  46.         RpcNull, "echo intr",            /* 1 - ECHO1, interrupt level */
  47.         RpcEcho, "echo",            /* 2 - ECHO2, server process */
  48.     RpcEcho, "send",            /* 3 - SEND, server process */
  49.         RpcNull,  "receive",            /* 4 - RECEIVE, unimplemented */
  50.         RpcGetTime, "get time",            /* 5 - GETTIME */
  51.     Fsrmt_RpcPrefix, "prefix",        /* 6 - FS_PREFIX */
  52.     Fsrmt_RpcOpen, "open",            /* 7 - FS_OPEN */
  53.         Fsrmt_RpcRead, "read",            /* 8 - FS_READ */
  54.         Fsrmt_RpcWrite, "write",        /* 9 - FS_WRITE */
  55.         Fsrmt_RpcClose, "close",        /* 10 - FS_CLOSE */
  56.         Fsrmt_RpcRemove, "remove",        /* 11 - FS_UNLINK */
  57.         Fsrmt_Rpc2Path, "rename",        /* 12 - FS_RENAME */
  58.         Fsrmt_RpcMakeDir, "makeDir",        /* 13 - FS_MKDIR */
  59.         Fsrmt_RpcRemove, "rmDir",        /* 14 - FS_RMDIR */
  60.     Fsrmt_RpcMakeDev, "make dev",        /* 15 - FS_MKDEV */
  61.         Fsrmt_Rpc2Path, "hard link",        /* 16 - FS_LINK */
  62.         RpcNull, "sym link",            /* 17 - FS_SYM_LINK */
  63.     Fsrmt_RpcGetAttr, "get attr",        /* 18 - FS_GET_ATTR */
  64.     Fsrmt_RpcSetAttr, "set attr",        /* 19 - FS_SET_ATTR */
  65.     Fsrmt_RpcGetAttrPath, "stat",        /* 20 - FS_GET_ATTR_PATH */
  66.     Fsrmt_RpcSetAttrPath, "setAttrPath",    /* 21 - FS_SET_ATTR_PATH */
  67.     Fsrmt_RpcGetIOAttr, "getIOAttr",    /* 22 - FS_GET_IO_ATTR */
  68.     Fsrmt_RpcSetIOAttr, "setIOAttr",    /* 23 - FS_SET_IO_ATTR */
  69.     Fsrmt_RpcDevOpen, "dev open",        /* 24 - FS_DEV_OPEN */
  70.     Fsrmt_RpcSelectStub, "select",        /* 25 - FS_SELECT */
  71.     Fsrmt_RpcIOControl, "io control",    /* 26 - FS_IO_CONTROL */
  72.     Fsconsist_RpcConsist, "consist",    /* 27 - FS_CONSIST */
  73.     Fsconsist_RpcConsistReply, "consist done",/* 28 - FS_CONSIST_REPLY */
  74.     Fsrmt_RpcBlockCopy, "copy block",    /* 29 - FS_COPY_BLOCK */
  75.     Fsrmt_RpcMigrateStream, "migrate",    /* 30 - FS_MIGRATE */
  76.     RpcNull, "release",            /* 31 - FS_RELEASE */
  77.     Fsrmt_RpcReopen, "reopen",        /* 32 - FS_REOPEN */
  78.     Fsutil_RpcRecovery, "recover",        /* 33 - FS_RECOVERY */
  79.     Fsrmt_RpcDomainInfo, "domain info",    /* 34 - FS_DOMAIN_INFO */
  80.     Proc_RpcMigCommand, "mig command",    /* 35 - PROC_MIG_COMMAND */
  81.     Proc_RpcRemoteCall, "rmt call",        /* 36 - PROC_REMOTE_CALL */
  82.     Proc_RpcRemoteWait, "remote wait",    /* 37 - PROC_REMOTE_WAIT */
  83.     Proc_RpcGetPCB, "get PCB",        /* 38 - PROC_GETPCB */
  84.     Sync_RemoteNotifyStub, "rmt notify",    /* 39 - REMOTE_WAKEUP */
  85.     Sig_RpcSend, "send signal",        /* 40 - SIG_SEND */
  86.     Fsio_RpcStreamMigCloseNew, "new release",/* 41 - FS_RELEASE_NEW */
  87.     Fsrmt_RpcBulkReopen, "bulkReopen",    /* 42 - FS_BULK_REOPEN */
  88.     Fsrmt_RpcServerReopen, "serverReopen",    /* 43 - FS_SERVER_REOPEN */
  89. };
  90.  
  91.  
  92. /*
  93.  *----------------------------------------------------------------------
  94.  *
  95.  * Rpc_FreeMem --
  96.  *
  97.  *    Free the memory that was allocated for a reply.
  98.  *
  99.  * Results:
  100.  *    None.
  101.  *
  102.  * Side effects:
  103.  *    Memory is freed.
  104.  *
  105.  *----------------------------------------------------------------------
  106.  */
  107. int
  108. Rpc_FreeMem(freeReplyData)
  109.     ClientData        freeReplyData;
  110. {
  111.     Rpc_ReplyMem    *replyMemPtr = (Rpc_ReplyMem *) freeReplyData;
  112.     if (replyMemPtr->paramPtr != (Address) NIL) {
  113.     free(replyMemPtr->paramPtr);
  114.     }
  115.     if (replyMemPtr->dataPtr != (Address) NIL) {
  116.     free(replyMemPtr->dataPtr);
  117.     }
  118.     free((Address) replyMemPtr);
  119.     return(0);
  120. }
  121.  
  122.  
  123. /*
  124.  *----------------------------------------------------------------------
  125.  *
  126.  * RpcNull --
  127.  *
  128.  *    The stub for the null procedure call.
  129.  *
  130.  * Results:
  131.  *    Always return the error code RPC_INVALID_RPC.
  132.  *
  133.  * Side effects:
  134.  *    None.
  135.  *
  136.  *----------------------------------------------------------------------
  137.  */
  138. /*ARGSUSED*/
  139. ReturnStatus
  140. RpcNull(srvToken, clientID, command, storagePtr)
  141.     ClientData srvToken;    /* Handle on server process passed to
  142.                  * Rpc_Reply */
  143.     int clientID;        /* Sprite ID of client host */
  144.     int command;        /* Command identifier */
  145.     Rpc_Storage *storagePtr;    /* The request fields refer to the request
  146.                  * buffers and also indicate the exact amount
  147.                  * of data in the request buffers.  The reply
  148.                  * fields are initialized to NIL for the
  149.                  * pointers and 0 for the lengths.  This can
  150.                  * be passed to Rpc_Reply */
  151. {
  152.     return(RPC_INVALID_RPC);
  153. }
  154.  
  155.  
  156. /*
  157.  *----------------------------------------------------------------------
  158.  *
  159.  * RpcEcho --
  160.  *
  161.  *    Service an echo request.  The input data is simply turned around
  162.  *    to the client.  This type of RPC is used for benchmarks, and
  163.  *    by hosts to query the status of other hosts (pinging).
  164.  *
  165.  * Results:
  166.  *    SUCCESS.
  167.  
  168.  * Side effects:
  169.  *    The echo.
  170.  *
  171.  *----------------------------------------------------------------------
  172.  */
  173. /*ARGSUSED*/
  174. int
  175. RpcEcho(srvToken, clientID, command, storagePtr)
  176.     ClientData srvToken;    /* Handle on server process passed to
  177.                  * Rpc_Reply */
  178.     int clientID;        /* Sprite ID of client host */
  179.     int command;        /* Command identifier */
  180.     Rpc_Storage *storagePtr;    /* The request fields refer to the request
  181.                  * buffers and also indicate the exact amount
  182.                  * of data in the request buffers.  The reply
  183.                  * fields are initialized to NIL for the
  184.                  * pointers and 0 for the lengths.  This can
  185.                  * be passed to Rpc_Reply */
  186. {
  187.     if (command == RPC_ECHO_2) {
  188.     /*
  189.      * The data is stored in buffers specified by the buffer set for
  190.      * the request message.  The correct length of the two parts is
  191.      * computed by the dispatcher and saved in the "actual" size fields.
  192.      */
  193.     storagePtr->replyParamPtr  = storagePtr->requestParamPtr;
  194.     storagePtr->replyParamSize = storagePtr->requestParamSize;
  195.     storagePtr->replyDataPtr   = storagePtr->requestDataPtr;
  196.     storagePtr->replyDataSize  = storagePtr->requestDataSize;
  197.     } else {
  198.     /*
  199.      * RPC_SEND has a null reply already set up by Rpc_Server.
  200.      */
  201.     }
  202.     Rpc_Reply(srvToken, SUCCESS, storagePtr, (int(*)()) NIL, (ClientData) NIL);
  203.     return (SUCCESS);
  204. }
  205.  
  206.  
  207. /*
  208.  *----------------------------------------------------------------------
  209.  *
  210.  * RpcGetTime --
  211.  *
  212.  *    Return the time of day.  The RPC_GET_TIME is done at boot time
  213.  *    by machines and used to initialize their rpcBootID, as well as
  214.  *    set their clock.  The point of the rpcBootID is to have a different
  215.  *    one each time a host boots so others can detect a reboot.  The
  216.  *    time obtained with this is usually overridden, however, with
  217.  *    an 'rdate' done by the bootcmds (much) later in the boot sequence.
  218.  *
  219.  * Results:
  220.  *    If SUCCESS is returned then reply has been sent.  Otherwise caller
  221.  *    will send the error reply.
  222.  *
  223.  * Side effects:
  224.  *    None.
  225.  *
  226.  *----------------------------------------------------------------------
  227.  */
  228. /*ARGSUSED*/
  229. ReturnStatus
  230. RpcGetTime(srvToken, clientID, command, storagePtr)
  231.     ClientData srvToken;    /* Handle on server process passed to
  232.                  * Rpc_Reply */
  233.     int clientID;        /* Sprite ID of client host */
  234.     int command;        /* Command identifier */
  235.     Rpc_Storage *storagePtr;    /* The request fields refer to the request
  236.                  * buffers and also indicate the exact amount
  237.                  * of data in the request buffers.  The reply
  238.                  * fields are initialized to NIL for the
  239.                  * pointers and 0 for the lengths.  This can
  240.                  * be passed to Rpc_Reply */
  241. {
  242.     Rpc_ReplyMem    *replyMemPtr;
  243.     struct timeReturn {
  244.     Time time;
  245.     int offset;
  246.     Boolean DST;
  247.     } *timeReturnPtr;
  248.     
  249.     timeReturnPtr =
  250.     (struct timeReturn *)malloc(sizeof(struct timeReturn));
  251.     Timer_GetTimeOfDay(&timeReturnPtr->time, &timeReturnPtr->offset,
  252.                      &timeReturnPtr->DST);
  253.     storagePtr->replyParamPtr = (Address)timeReturnPtr;
  254.     storagePtr->replyParamSize = sizeof(struct timeReturn);
  255.  
  256.     replyMemPtr = (Rpc_ReplyMem *) malloc(sizeof(Rpc_ReplyMem));
  257.     replyMemPtr->paramPtr = storagePtr->replyParamPtr;
  258.     replyMemPtr->dataPtr = (Address) NIL;
  259.  
  260.     Rpc_Reply(srvToken, SUCCESS, storagePtr, Rpc_FreeMem,
  261.         (ClientData) replyMemPtr);
  262.     return(SUCCESS);
  263. }
  264.  
  265.